//import java.util.ArrayList;
//import java.util.Collection;
//import java.util.Iterator;
//import java.util.List;
//import java.util.concurrent.*;
//public class NettyStudy {
//    public abstract class AbstractExecutorService implements ExecutorService {
//        // 将Runnable对象封装为FutureTask
//        protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
//            return new FutureTask<T>(runnable, value);
//        }
//        // 将Callable对象封装为FutureTask
//        protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
//            return new FutureTask<T>(callable);
//        }
//        // 封装Runnable task,然后调用execute执行
//        public Future<?> submit(Runnable task) {
//            if (task == null) throw new NullPointerException();
//            RunnableFuture<Void> ftask = newTaskFor(task, null);
//            execute(ftask);
//            return ftask;
//        }
//        // 封装Runnable task,然后调用execute执行。注意,这里还封装了结果
//        public <T> Future<T> submit(Runnable task, T result) {
//            if (task == null) throw new NullPointerException();
//            RunnableFuture<T> ftask = newTaskFor(task, result);
//            execute(ftask);
//            return ftask;
//        }
//        // 封装Callable task,然后调用execute执行
//        public <T> Future<T> submit(Callable<T> task) {
//            if (task == null) throw new NullPointerException();
//            RunnableFuture<T> ftask = newTaskFor(task);
//            execute(ftask);
//            return ftask;
//        }
//        /* 执行传入的任务,只要任何一个任务被执行完成就返回,然后取消其他任务,这里Any指
//           任何一个tasks中的任务执行完成,timed和nanos用来表明执行超时时间 */
//        private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks, boolean timed, long nanos) throws InterruptedException, ExecutionException,
//                TimeoutException {
//            // 任务判空
//            if (tasks == null) throw new NullPointerException();
//            int ntasks = tasks.size();
//            if (ntasks == 0) throw new IllegalArgumentException();
//            // 创建用于保存执行stub的future对象的集合
//            ArrayList<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
//            // 创建ExecutorCompletionService用于执行任务
//            ExecutorCompletionService<T> ecs = new ExecutorCompletionService<T>(this);
//            try {
//                // 记录异常,这样如果我们不能获得任何result,可以抛出最后一个异常。
//                ExecutionException ee = null;
//                final long deadline = timed ? System.nanoTime() + nanos : 0L;
//                // 获取集合的迭代器
//                Iterator<? extends Callable<T>> it = tasks.iterator();
//                // 先开始一项任务,其余的增量执行
//                futures.add(ecs.submit(it.next()));
//                // 任务数减1
//                --ntasks;
//                // 正在执行的任务为1
//                int active = 1;
//                for (; ; ) {
//                    /* 从ExecutorCompletionService中获取一个执行任务的future,如果future为空,判
//                    断任务数量是否大于0,如果还有下一个任务,继续递交执行。如果future不为空,
//                    直接调用 f.get()返回执行结果,然后在finally中取消所有任务。读者可能会问,
//                    ExecutorCompletionService是什么？很简单,看看它的构造器:
//                    ExecutorCompletionService(Executor executor,BlockingQueue<Future<V>>
//                    completionQueue),一个执行器,一个阻塞队列,功能是在执行器executor
//                    中执行任务,任务完成后将结果放入completionQueue队列中,然后生产端从这个
//                    队列中获取结果。这就是生产者消费者模型 */
//                    Future<T> f = ecs.poll();
//                    if (f == null) {
//                        if (ntasks > 0) {
//                            --ntasks;
//                            futures.add(ecs.submit(it.next()));
//                            ++active;
//                        } else if (active == 0)
//                            break;
//                        else if (timed) {
//                          /* 如果指定了超时时间,等待nanos纳秒后如果future还是为空,则
//                           抛出超时异常 */
//                            f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
//                            if (f == null)
//                                throw new TimeoutException();
//                            nanos = deadline - System.nanoTime();
//                        } else
//                          /* 当然,如果所有任务都放到线程池里执行了,那么直接调用take方法
//                           阻塞当前线程,等待任务执行完成后返回。poll方法非阻塞或者带超时
//                           时间的阻塞,take方法阻塞直到队列里放入结果,这里是future */
//                            f = ecs.take();
//                    }
//                    if (f != null) {
//                        --active;
//                        try {
//                            return f.get();
//                        } catch (ExecutionException eex) {
//                            ee = eex;
//                        } catch (RuntimeException rex) {
//                            ee = new ExecutionException(rex);
//                        }
//                    }
//                }
//                if (ee == null)
//                    ee = new ExecutionException();
//                throw ee;
//            } finally {
//                for (int i = 0, size = futures.size();
//                     i < size;
//                     i++)
//                    // 传入true表明中断执行线程
//                    futures.get(i).cancel(true);
//            }
//        }
//        // 间接调用doInvokeAny
//        public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
//                throws InterruptedException, ExecutionException {
//            try {
//                return doInvokeAny(tasks, false, 0);
//            } catch (TimeoutException cannotHappen) {
//                return null;
//            }
//        }
//        // 带超时时间的间接调用doInvokeAny
//        public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
//                               long timeout, TimeUnit unit)
//                throws InterruptedException, ExecutionException, TimeoutException {
//            return doInvokeAny(tasks, true, unit.toNanos(timeout));
//        }
//        /* 上面的invokeAny为其中一个任务执行完成后返回,这里的invokeAll和大家想的一样,直接
//         翻译All就行,就是执行所有传入的任务,然后等待所有任务执行完毕后返回 */
//        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
//                throws InterruptedException {
//            if (tasks == null) throw new NullPointerException();
//            // 同样先来一个保存future对象的arraylist
//            ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
//            boolean done = false;
//            try {
//                // 直接遍历所有tasks来调用execute,以将其放到线程池中全部执行,将future放入集合中
//                for (Callable<T> t : tasks) {
//                    RunnableFuture<T> f = newTaskFor(t);
//                    futures.add(f);
//                    execute(f);
//                }
//               /* 然后遍历future,等待每一个任务执行。注意这里的异常处理,当其中一个future
//                发生执行异常时则直接忽略掉,还是会设置done为true表明完成执行,
//                最后返回future,所以调用者应自行检查future是否发生了异常 */
//                for (int i = 0, size = futures.size();
//                     i < size;
//                     i++) {
//                    Future<T> f = futures.get(i);
//                    if (!f.isDone()) {
//                        try {
//                            f.get();
//                        } catch (CancellationException ignore) {
//                        } catch (ExecutionException ignore) {
//                        }
//                    }
//                }
//                done = true;
//                return futures;
//            } finally {
///*                如果发生异常导致任务执行失败,即不属于CancellationException和
//                ExecutionException,那么取消所有的任务 */
//                if (!done)
//                    for (int i = 0, size = futures.size();
//                         i < size;
//                         i++)
//                        futures.get(i).cancel(true);
//            }
//        }
//        // 带超时时间的执行所有任务
//        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
//                                             long timeout, TimeUnit unit)
//                throws InterruptedException {
//            if (tasks == null) throw new NullPointerException();
//            // 将超时时间转为纳秒
//            long nanos = unit.toNanos(timeout);
//            ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
//            boolean done = false;
//            try {
//   /* 遍历执行所有任务,将其转变为FutureTask放入future集合中,然后计算deadline
//    超时时间 */
//                for (Callable<T> t : tasks)
//                    futures.add(newTaskFor(t));
//                final long deadline = System.nanoTime() + nanos;
//                final int size = futures.size();
//   /* 遍历所有的任务,开始执行。如果达到超时时间,直接返回futures。可以看到,
//    超时时间设置过短,会导致任务未开始执行就返回,而且没有取消任务,这时
//    返回的futures中有可能还在线程池中执行。这点在使用时务必小心 */
//                for (int i = 0; i < size; i++) {
//                    execute((Runnable) futures.get(i));
//                    nanos = deadline - System.nanoTime();
//                    if (nanos <= 0L)
//                        return futures;
//                }
//   /* 到这里,所有任务都放到了线程池中执行。遍历所有的future,根据超时时间选择
//     返回或者等待 */
//                for (int i = 0; i < size; i++) {
//                    Future<T> f = futures.get(i);
//                    if (!f.isDone()) {
//                        if (nanos <= 0L)
//                            return futures;
//                        try {
//                            f.get(nanos, TimeUnit.NANOSECONDS);
//                        } catch (CancellationException ignore) {
//                        } catch (ExecutionException ignore) {
//                        } catch (TimeoutException toe) {
//                            return futures;
//                        }
//                        nanos = deadline - System.nanoTime();
//                    }
//                }
//                done = true;
//                return futures;
//            } finally {
//                // 同样,如果出现未知异常,那么直接取消所有任务
//                if (!done)
//                    for (int i = 0, size = futures.size();
//                         i < size;
//                         i++)
//                        futures.get(i).cancel(true);
//            }
//        }
//    }
//    public interface ExecutorService extends Executor {
//        // 关闭服务
//        void shutdown();
//        // 立刻关闭服务
//        List<Runnable> shutdownNow();
//        // 判断服务是否调用了shutdown
//        boolean isShutdown();
//        // 判断服务是否完全终止
//        boolean isTerminated();
//        // 等待当前服务停止
//        boolean awaitTermination(long timeout, TimeUnit unit)
//                throws InterruptedException;
//        // 提交一个任务Callable task,返回一个存根stub
//        <T> Future<T> submit(Callable<T> task);
//        // 提交一个任务Runnable task,返回一个存根stub
//        Future<?> submit(Runnable task);
//        // 提交一组callable任务执行,返回所有任务的存根stub
//        <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
//                throws InterruptedException;
//        // 提交一组任务Callable task,返回所有任务的存根stub。注意,这个包含了等待执行的时间
//        <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
//                                      long timeout, TimeUnit unit)
//                throws InterruptedException;
//        // 提交一组任务,等待其中任何一个任务完成后返回
//        <T> T invokeAny(Collection<? extends Callable<T>> tasks)
//                throws InterruptedException, ExecutionException;
//        // 提交一组任务,等待其中任何一个任务完成后返回。注意,这个包含了等待执行的时间
//        <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
//                throws InterruptedException, ExecutionException, TimeoutException;
//    }
//    public interface EventExecutorGroup extends ScheduledExecutorService, Iterable<EventExecutor> {
//        // 用于判断当前EventExecutorGroup管理的所有EventExecutor是否正在关闭
//        boolean isShuttingDown();
//        // 用于安全关闭执行器组
//        Future<?> shutdownGracefully(); // 通过默认值调用下面有参的方法完成关闭
//        Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit); // 通知执行器组当前需要关闭。一旦该方法被调用，那么isShuttingDown方法将返回true，并且执行器将开始执行关闭动作。
//        // 获取一个Future对象，该对象将在当前EventExecutorGroup管理的所有EventExecutor是否都已经终止后被设置完成
//        Future<?> terminationFuture();
//        // 用于获取一个当前EventExecutorGroup管理的EventExecutor
//        EventExecutor next();
//    }
//    public interface EventExecutor extends EventExecutorGroup {
//        /**
//         * 由于当前事件执行器组只有他自己，那么next永远返回他自己
//         */
//        @Override
//        EventExecutor next();
//        /**
//         * 返回该事件执行器所属的时间执行器组EventExecutorGroup
//         */
//        EventExecutorGroup parent();
//        /**
//         * 通过Thread.currentThread()检测当前线程是否为当前EventExecutor的绑定执行线程
//         */
//        boolean inEventLoop();
//        /**
//         * 指定线程对象来判断，同inEventLoop方法
//         */
//        boolean inEventLoop(Thread thread);
//        /**
//         * 生成一个新的Promise实例
//         */
//        <V> Promise<V> newPromise();
//        /**
//         * 生成一个新的ProgressivePromise实例
//         */
//        <V> ProgressivePromise<V> newProgressivePromise();
//        /**
//         * 创建一个新的Future实例，但是通过result参数指定Future的结果，并标记已经成功完成
//         */
//        <V> Future<V> newSucceededFuture(V result);
//        /**
//         * 创建一个新的Future实例，但是通过cause参数指定Future的异常结果，并标记已经失败完成
//         */
//        <V> Future<V> newFailedFuture(Throwable cause);
//    }
//    public abstract class AbstractEventExecutorGroup implements EventExecutorGroup {
//        // 用于向EventExecutorGroup执行器组提交Runnable任务
//        @Override
//        public Future<?> submit(Runnable task) {
//            return next().submit(task);
//        }
//        // 用于向EventExecutorGroup执行器组提交Runnable任务并指定结果值
//        @Override
//        public <T> Future<T> submit(Runnable task, T result) {
//            return next().submit(task, result);
//        }
//        // 用于向EventExecutorGroup执行器组提交Callable任务并指定结果值
//        @Override
//        public <T> Future<T> submit(Callable<T> task) {
//            return next().submit(task);
//        }
//        // 用于向EventExecutorGroup执行器组提交延迟执行的Runnable任务
//        @Override
//        public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
//            return next().schedule(command, delay, unit);
//        }
//        // 用于向EventExecutorGroup执行器组提交延迟执行的Callable任务
//        @Override
//        public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
//            return next().schedule(callable, delay, unit);
//        }
//        // 用于向EventExecutorGroup执行器组提交周期性执行的Runnable任务
//        @Override
//        public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
//            return next().scheduleAtFixedRate(command, initialDelay, period, unit);
//        }
//        // 用于向EventExecutorGroup执行器组提交周期性执行的Runnable任务
//        @Override
//        public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
//            return next().scheduleWithFixedDelay(command, initialDelay, delay, unit);
//        }
//        // 通过指定默认参数来调用shutdownGracefully方法完成优雅关闭。DEFAULT_SHUTDOWN_QUIET_PERIOD = 2、DEFAULT_SHUTDOWN_TIMEOUT = 15
//        @Override
//        public Future<?> shutdownGracefully() {
//            return shutdownGracefully(DEFAULT_SHUTDOWN_QUIET_PERIOD, DEFAULT_SHUTDOWN_TIMEOUT, TimeUnit.SECONDS);
//        }
//        // 废弃不用，推荐使用shutdownGracefully()
//        @Override
//        @Deprecated
//        public abstract void shutdown();
//        // 废弃不用，推荐使用shutdownGracefully()
//        @Override
//        @Deprecated
//        public List<Runnable> shutdownNow() {
//            shutdown();
//            return Collections.emptyList();
//        }
//        // 执行所有提交的集合中的任务
//        @Override
//        public <T> List<java.util.concurrent.Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
//                throws InterruptedException {
//            return next().invokeAll(tasks);
//        }
//        // 执行所有提交的集合中的任务,可以指定任务超时时间
//        @Override
//        public <T> List<java.util.concurrent.Future<T>> invokeAll(
//                Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
//            return next().invokeAll(tasks, timeout, unit);
//        }
//        // 执行集合中的任务，直到有一个任务被执行完成
//        @Override
//        public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
//            return next().invokeAny(tasks);
//        }
//        // 执行集合中的任务，直到有一个任务被执行完成，可以指定等待时间
//        @Override
//        public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
//                throws InterruptedException, ExecutionException, TimeoutException {
//            return next().invokeAny(tasks, timeout, unit);
//        }
//        // 执行传入的任务对象
//        @Override
//        public void execute(Runnable command) {
//            next().execute(command);
//        }
//    }
//    public interface EventExecutorChooserFactory {
//        /**
//         * 返回新的EventExecutorChooser实例
//         */
//        EventExecutorChooser newChooser(EventExecutor[] executors);
//        // 定义选择功能方法
//        interface EventExecutorChooser {
//            /**
//             * 返回下一个子执行器
//             */
//            EventExecutor next();
//        }
//    }
//    // 默认选择器工厂
//    public final class DefaultEventExecutorChooserFactory implements EventExecutorChooserFactory {
//        // 默认单例
//        public static final DefaultEventExecutorChooserFactory INSTANCE = new DefaultEventExecutorChooserFactory();
//        private DefaultEventExecutorChooserFactory() {
//        }
//        // 通过executors子执行器数组来完成创建。通过检测子执行器数组的长度来选择对应的EventExecutorChooser实例
//        @Override
//        public EventExecutorChooser newChooser(EventExecutor[] executors) {
//            if (isPowerOfTwo(executors.length)) {
//                return new PowerOfTowEventExecutorChooser(executors);
//            } else {
//                return new GenericEventExecutorChooser(executors);
//            }
//        }
//        // 笔者说过：二进制的与操作符等于二进制截断，那么这里相当于对val本身和其负数值截断，比如：val为8，那么二进制为：(这里为32位，前面的28个0省略)1000，-8为：（省略28个1）1000，那么执行与操作符，此时截断了前面29个1的值，这时为原值，表明为2的倍数。但是如果：val为7，那么二进制为111，-7为：（省略29个1）001，此时执行与运算，那么将截断为1
//        private static boolean isPowerOfTwo(int val) {
//            return (val & -val) == val;
//        }
//        // 数组长度为2的倍数时，我们可以用二进制截断来实现：idx.getAndIncrement() & executors.length - 1，通过与运算加速取余数操作。还是以8为例，8-1=7，二进制为0111，此时截断idx.getAndIncrement()的低三位，正好落在数组 0 - 7的index上
//        private static final class PowerOfTowEventExecutorChooser implements EventExecutorChooser {
//            private final AtomicInteger idx = new AtomicInteger(); // 原子性自增（就算溢出为负数，也不影响）
//            private final EventExecutor[] executors;
//            PowerOfTowEventExecutorChooser(EventExecutor[] executors) {
//                this.executors = executors;
//            }
//            @Override
//            public EventExecutor next() {
//                return executors[idx.getAndIncrement() & executors.length - 1];
//            }
//        }
//        // 数组长度不为2的倍数，那么只能用相对较慢的abs取绝对值，然后%来计算长度。为何取绝对值？AtomicInteger溢出为负数怎么办？
//        private static final class GenericEventExecutorChooser implements EventExecutorChooser {
//            private final AtomicInteger idx = new AtomicInteger();
//            private final EventExecutor[] executors;
//            GenericEventExecutorChooser(EventExecutor[] executors) {
//                this.executors = executors;
//            }
//            @Override
//            public EventExecutor next() {
//                return executors[Math.abs(idx.getAndIncrement() % executors.length)];
//            }
//        }
//    }
//    public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {
//        private final EventExecutor[] children; // 子事件执行器数组（执行器组）
//        private final Set<EventExecutor> readonlyChildren; // 只读子事件执行器
//        private final AtomicInteger terminatedChildren = new AtomicInteger(); // 已经终止的子事件执行器数量
//        private final Promise<?> terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);// 子事件执行器终止Promise对象，我们可以在关闭执行器组时通过该Future接口来异步获取关闭结果
//        private final EventExecutorChooserFactory.EventExecutorChooser chooser; // 用于从子执行器数组中根据该接口的实例来完成下一个子执行器的获取（负载均衡器）
//        // 构造函数，提供了默认的线程工厂：ThreadPerTaskExecutor
//        protected MultithreadEventExecutorGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
//            this(nThreads, threadFactory == null ? null : new ThreadPerTaskExecutor(threadFactory), args);
//        }
//        // 构造函数提供默认的EventExecutorChooser实例：DefaultEventExecutorChooserFactory.INSTANCE
//        protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
//            this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
//        }
//        // 完整构造器
//        protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
//                                                EventExecutorChooserFactory chooserFactory, Object... args) {
//            if (nThreads <= 0) { // 参数校验
//                throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
//            }
//            if (executor == null) { // Executor实例未指定的情况下，创建默认的ThreadPerTaskExecutor实例
//                executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
//            }
//            children = new EventExecutor[nThreads]; // 创建子执行器数组
//            for (int i = 0; i < nThreads; i++) { // 初始化子执行器数组
//                boolean success = false;
//                try {
//                    children[i] = newChild(executor, args); // 调用子类实现的创建子执行器的方法来完成初始化（为何如此设计？很明显：当前类并不知道这个子执行器的实例是谁，我只知道需要创建而已，抽象方法的魅力再一次展现）
//                    success = true;
//                } catch (Exception e) {
//                    // 创建出现异常，那么包装异常对象
//                    throw new IllegalStateException("failed to create a child event loop", e);
//                } finally {
//                    if (!success) { // 只要有一个子执行器创建实例失败，那么需要全部关闭
//                        for (int j = 0; j < i; j++) {
//                            children[j].shutdownGracefully();
//                        }
//                        for (int j = 0; j < i; j++) { // 当前线程等待子执行器全部关闭
//                            EventExecutor e = children[j];
//                            try {
//                                while (!e.isTerminated()) {
//                                    e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
//                                }
//                            } catch (InterruptedException interrupted) { // 等待期间被中断唤醒，那么将当前线程中断标志位重置（中断异常会消耗标志位），由调用方来处理该中断
//                                Thread.currentThread().interrupt();
//                                break;
//                            }
//                        }
//                    }
//                }
//            }
//            chooser = chooserFactory.newChooser(children); // 通过工厂创建选择器
//// 创建终止监听器，并将该监听器放入子执行器中。可以看到该监听器，在操作完成时，对当前类的terminatedChildren终止线程数进行自增，当最后一个子执行器执行完成后，设置terminationFuture的成功结果为null，表示终止完成
//            final FutureListener<Object> terminationListener = new FutureListener<Object>() {
//                @Override
//                public void operationComplete(Future<Object> future) throws Exception {
//                    if (terminatedChildren.incrementAndGet() == children.length) {
//                        terminationFuture.setSuccess(null);
//                    }
//                }
//            };
//            for (EventExecutor e : children) {
//                e.terminationFuture().addListener(terminationListener);
//            }
//            // 一旦执行器数组创建完成，那么将设置其为只读执行器，不允许任何修改
//            Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
//            Collections.addAll(childrenSet, children);
//            readonlyChildren = Collections.unmodifiableSet(childrenSet);
//        }
//    }
//    public final class ThreadPerTaskExecutor implements Executor {
//        private final ThreadFactory threadFactory;
//        public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
//            if (threadFactory == null) {
//                throw new NullPointerException("threadFactory");
//            }
//            this.threadFactory = threadFactory;
//        }
//        @Override
//        public void execute(Runnable command) {
//            threadFactory.newThread(command).start();
//        }
//    }
//    public class DefaultThreadFactory implements ThreadFactory {
//        private static final AtomicInteger poolId = new AtomicInteger(); // 线程池ID，用于生成线程名
//        private final AtomicInteger nextId = new AtomicInteger(); // 线程ID，用于生成线程名
//        private final String prefix; // 生成的线程名前缀
//        private final boolean daemon; // 是否为守护线程
//        private final int priority;// 线程优先级
//        protected final ThreadGroup threadGroup;// 线程组
//        // 完整构造器。在对参数进行校验后，保存生成线程前缀、是否为daemon守护线程、优先级、所属线程组
//        public DefaultThreadFactory(String poolName, boolean daemon, int priority, ThreadGroup threadGroup) {
//            if (poolName == null) {
//                throw new NullPointerException("poolName");
//            }
//            if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
//                throw new IllegalArgumentException(
//                        "priority: " + priority + " (expected: Thread.MIN_PRIORITY <= priority <= Thread.MAX_PRIORITY)");
//            }
//            prefix = poolName + '-' + poolId.incrementAndGet() + '-';
//            this.daemon = daemon;
//            this.priority = priority;
//            this.threadGroup = threadGroup;
//        }
//        // 生成新的线程对象
//        @Override
//        public Thread newThread(Runnable r) {
//            Thread t = newThread(new DefaultRunnableDecorator(r), prefix + nextId.incrementAndGet());
//            // 设置线程属性
//            try {
//                if (t.isDaemon()) {
//                    if (!daemon) {
//                        t.setDaemon(false);
//                    }
//                } else {
//                    if (daemon) {
//                        t.setDaemon(true);
//                    }
//                }
//                if (t.getPriority() != priority) {
//                    t.setPriority(priority);
//                }
//            } catch (Exception ignored) {
//                // Doesn't matter even if failed to set.
//            }
//            return t;
//        }
//        // 创建线程对象
//        protected Thread newThread(Runnable r, String name) {
//            return new FastThreadLocalThread(threadGroup, r, name);
//        }
//        // 用于装饰需要执行的Runnable任务，标准的装饰者模式。这里主要对任务进行封装，在任务执行完毕后，移除ThreadLocal的存储，避免内存泄漏
//        private static final class DefaultRunnableDecorator implements Runnable {
//            private final Runnable r;
//            DefaultRunnableDecorator(Runnable r) {
//                this.r = r;
//            }
//            @Override
//            public void run() {
//                try {
//                    r.run();
//                } finally {
//                    FastThreadLocal.removeAll();
//                }
//            }
//        }
//    }
//    public class FastThreadLocalThread extends Thread {
//        private InternalThreadLocalMap threadLocalMap;
//        public final InternalThreadLocalMap threadLocalMap() {
//            return threadLocalMap;
//        }
//        public final void setThreadLocalMap(InternalThreadLocalMap threadLocalMap) {
//            this.threadLocalMap = threadLocalMap;
//        }
//    }
//    public class ThreadLocal<T> {
//        // 设置线程本地变量
//        public void set(T value) {
//            Thread t = Thread.currentThread(); // 获取当前线程
//            ThreadLocalMap map = getMap(t); // 获取线程map
//            if (map != null) // map不为空，那么直接放入
//                map.set(this, value);
//            else
//                createMap(t, value); // 否则创建线程map
//        }
//        // 获取线程map。可以看到这里直接取线程对象的ThreadLocal.ThreadLocalMap对象
//        ThreadLocalMap getMap(Thread t) {
//            return t.threadLocals;
//        }
//        // 创建线程map，可以看到这里初始化了ThreadLocalMap对象
//        void createMap(Thread t, T firstValue) {
//            t.threadLocals = new ThreadLocalMap(this, firstValue);
//        }
//        // 用于处理ThreadLocal和value映射的线程map
//        static class ThreadLocalMap {
//            private Entry[] table; // 保存映射的数组
//            ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//                table = new Entry[INITIAL_CAPACITY]; // 创建数组
//                int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); // 计算当前ThreadLocal中对应value的下标
//                table[i] = new Entry(firstKey, firstValue); // 将映射关系放入下标所在的entry中
//                size = 1;
//                setThreshold(INITIAL_CAPACITY);
//            }
//            // 将指定的映射关系放入对应的数组下标
//            private void set(ThreadLocal<?> key, Object value) {
//                Entry[] tab = table;
//                int len = tab.length;
//                int i = key.threadLocalHashCode & (len - 1); // 根据hash值计算该映射关系应该放置的索引下标
//                ... // 省略掉发生冲突二次寻址的过程
//                tab[i] = new Entry(key, value); // 创建新的entry
//                ...
//            }
//            // 根据ThreadLocal对象来获取映射值
//            private Entry getEntry(ThreadLocal<?> key) {
//                int i = key.threadLocalHashCode & (table.length - 1);
//                ...
//            }
//        }
//    }
//    public class FastThreadLocal<V> {
//        private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex(); // 该类创建时生成的唯一id，通常为0
//        private final int index; // 当前FastThreadLocal在InternalThreadLocalMap中的下标
//        public FastThreadLocal() { // 创建对象时生成唯一的下标
//            index = InternalThreadLocalMap.nextVariableIndex();
//        }
//        public final void set(V value) {
//            if (value != InternalThreadLocalMap.UNSET) { // value不是占位对象UNSET，那么直接设置
//                set(InternalThreadLocalMap.get(), value);
//            } else { // 否则执行清理操作
//                remove();
//            }
//        }
//        public final void set(InternalThreadLocalMap threadLocalMap, V value) {
//            if (value != InternalThreadLocalMap.UNSET) { // 由于该方法是通用方法，所以这里还得检测一次占位对象
//                if (threadLocalMap.setIndexedVariable(index, value)) { // 注意：这里直接根据index下标设置值即可
//                    addToVariablesToRemove(threadLocalMap, this); // 设置成功，那么将当前FastThreadLocal对象添加到threadLocalMap对应的variablesToRemoveIndex下标处，表明需要进行清理的FastThreadLocal（这里通常为0下标）
//                }
//            } else {
//                remove(threadLocalMap);
//            }
//        }
//        // 将FastThreadLocal<?> variable添加到InternalThreadLocalMap threadLocalMap对应的下标处
//        private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, <?>variable) {
//            Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex); // 获取对应的下标值
//            Set<FastThreadLocal<?>> variablesToRemove;
//            if (v == InternalThreadLocalMap.UNSET || v == null) { // 如果集合不存在，那么创建集合
//                variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
//                threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
//            } else { // 否则将已经存在的v转为Set<FastThreadLocal<?>>集合
//                variablesToRemove = (Set < FastThreadLocal < ? >> Set < FastThreadLocal < ?>>)v;
//            }
//            // 将FastThreadLocal对象放入集合
//            variablesToRemove.add(variable);
//        }
//        // 清理当前FastThreadLocal在InternalThreadLocalMap中的存储
//        public final void remove(InternalThreadLocalMap threadLocalMap) {
//            if (threadLocalMap == null) {
//                return;
//            }
//            Object v = threadLocalMap.removeIndexedVariable(index); // 从threadLocalMap对应的index下标中移除该对象，并设置为UNSET，返回该对象值
//            removeFromVariablesToRemove(threadLocalMap, this); // 由于该FastThreadLocal的映射值已经从InternalThreadLocalMap中移除，那么需要将其从下标为variablesToRemoveIndex处的Set集合中移除
//            if (v != InternalThreadLocalMap.UNSET) { // 如果移除成功，那么回调钩子方法（默认为空，子类可以重写来完成自己的逻辑）
//                try {
//                    onRemoval((V) v);
//                } catch (Exception e) {
//                    PlatformDependent.throwException(e);
//                }
//            }
//        }
//        // 将指定的FastThreadLocal从InternalThreadLocalMap中对应下标为variablesToRemoveIndex（通常为0）中的Set集合中移除
//        private static void removeFromVariablesToRemove(
//                InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
//            // 获取set集合并掉用其remove方法移除
//            Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
//            if (v == InternalThreadLocalMap.UNSET || v == null) {
//                return;
//            }
//            Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
//            variablesToRemove.remove(variable);
//        }
//        // 直接移除操作，可以看到直接获取当前线程的InternalThreadLocalMap对象，然后调用上述的remove(InternalThreadLocalMap threadLocalMap) 方法
//        public final void remove() {
//            remove(InternalThreadLocalMap.getIfSet());
//        }
//    }
//    public class FastThreadLocal<V> {
//        public static void removeAll() {
//            InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet(); // 获取当前线程的InternalThreadLocalMap
//            if (threadLocalMap == null) {
//                return;
//            }
//            try {
//                Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex); // 获取下标为0的set集合，该集合保留了当前线程所有的FastThreadLocal变量
//                if (v != null && v != InternalThreadLocalMap.UNSET) { // 集合存在，那么遍历调用FastThreadLocal的remove方法移除
//                    @SuppressWarnings("unchecked")
//                    Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
//                    FastThreadLocal<?>[] variablesToRemoveArray =
//                            variablesToRemove.toArray(new FastThreadLocal[variablesToRemove.size()]);
//                    for (FastThreadLocal<?> tlv : variablesToRemoveArray) {
//                        tlv.remove(threadLocalMap);
//                    }
//                }
//            } finally { // 最后调用InternalThreadLocalMap的remove静态方法，完成最终的清理操作（其实就是将FastThreadLocalThread的InternalThreadLocalMap threadLocalMap置空，因为这个map已经无用了）
//                InternalThreadLocalMap.remove();
//            }
//        }
//    }
//    class UnpaddedInternalThreadLocalMap {
//        static final ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = new ThreadLocal<InternalThreadLocalMap>(); // 兼容原生的JDK ThreadLocal ，注意这里的类型为InternalThreadLocalMap，这是何意？继续往下看
//        static final AtomicInteger nextIndex = new AtomicInteger(); // 原子性生成下一个索引下标
//        Object[] indexedVariables; // 核心变量，用于保存ThreadLocal的变量值（还记得前面的FastThreadLocal的index下标么）
//        UnpaddedInternalThreadLocalMap(Object[] indexedVariables) {
//            this.indexedVariables = indexedVariables;
//        }
//    }
//    public final class InternalThreadLocalMap extends UnpaddedInternalThreadLocalMap {
//        public static final Object UNSET = new Object(); // 表明未使用的InternalThreadLocalMap下标占位符
//        // 构造器初始化父类的Object[] indexedVariables数组，可以看到默认数组长度为32
//        private InternalThreadLocalMap() {
//            super(newIndexedVariableTable());
//        }
//        private static Object[] newIndexedVariableTable() {
//            Object[] array = new Object[32];
//            Arrays.fill(array, UNSET);
//            return array;
//        }
//        // 获取当前线程所属的InternalThreadLocalMap对象。根据当前线程类型是否为FastThreadLocalThread，从而调用fastGet或者slowGet获取InternalThreadLocalMap。因为只有FastThreadLocalThread内部直接拥有InternalThreadLocalMap引用。
//        public static InternalThreadLocalMap get() {
//            Thread thread = Thread.currentThread();
//            if (thread instanceof FastThreadLocalThread) {
//                return fastGet((FastThreadLocalThread) thread);
//            } else {
//                return slowGet();
//            }
//        }
//        // 从当前FastThreadLocalThread属性变量中获取InternalThreadLocalMap对象，如果不存在，那么在这里将会进行初始化
//        private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
//            InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
//            if (threadLocalMap == null) {
//                thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
//            }
//            return threadLocalMap;
//        }
//        // 当前线程不是FastThreadLocalThread，那么从线程原生的ThreadLocalMap中获取InternalThreadLocalMap，当然，如果这里不存在，那么将会初始化InternalThreadLocalMap对象，然后再将其放入原生的ThreadLocal中
//        private static InternalThreadLocalMap slowGet() {
//            ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
//            InternalThreadLocalMap ret = slowThreadLocalMap.get();
//            if (ret == null) {
//                ret = new InternalThreadLocalMap();
//                slowThreadLocalMap.set(ret);
//            }
//            return ret;
//        }
//        // 将当前线程中的InternalThreadLocalMap移除。这里同样分为FastThreadLocalThread和普通线程。如果是FastThreadLocalThread那么直接设置保存的引用为null即可，如果是普通Thread，那么直接调用原生ThreadLocal的remove方法即可
//        public static void remove() {
//            Thread thread = Thread.currentThread();
//            if (thread instanceof FastThreadLocalThread) {
//                ((FastThreadLocalThread) thread).setThreadLocalMap(null);
//            } else {
//                slowThreadLocalMap.remove();
//            }
//        }
//    }
//    public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) {
//        for (EventExecutor l: children) {
//            l.shutdownGracefully(quietPeriod, timeout, unit);
//            return terminationFuture();
//        }
//    }
//    public Future<?> terminationFuture() { // 返回terminationFuture实例
//        return terminationFuture;
//    }
//    public boolean awaitTermination(long timeout, TimeUnit unit)
//            throws InterruptedException {
//        long deadline = System.nanoTime() + unit.toNanos(timeout);
//        loop: for (EventExecutor l: children) {
//            for (;;) {
//                long timeLeft = deadline - System.nanoTime();
//                if (timeLeft <= 0) {
//                    break loop;
//                }
//                if (l.awaitTermination(timeLeft, TimeUnit.NANOSECONDS)) {
//                    break;
//                }
//            }
//        }
//        return isTerminated();
//    }
//    public boolean isTerminated() { // 判断子执行器是否终止，可以看到遍历自执行器数组，如果有一个未终止，那么均返回false
//        for (EventExecutor l: children) {
//            if (!l.isTerminated()) {
//                return false;
//            }
//        }
//        return true;
//    }
//}
